// streamable.go ~L1486
if metaVersion == "" {
    writeJSONRPCError(w, http.StatusBadRequest, ...)
}

// Define types
type SayHiParams struct {
    Name string `json:"name"`
}

// Register — one line, types inferred
mcp.AddTool(server, &mcp.Tool{Name: "greet"}, SayHi)

// Call — first-class method on session, no generics visible
res, err := cs.CallTool(ctx, &mcp.CallToolParams{Name: "greet", Arguments: map[string]any{"name": "user"}})

// Server — generics visible
mcp.AddReceivingCustomMethod(server, "latin/translate", handler)

// Client — must register separately, generics repeated
mcp.AddSendingCustomMethod[*TranslateParams, *TranslateResult](client, "latin/translate")

// Call — generics repeated AGAIN, method name string repeated AGAIN
result, err := mcp.CallCustomMethod[*TranslateParams, *TranslateResult](
    ctx, cs, "latin/translate", &TranslateParams{Text: "hello"})

// CustomMethod captures method name + types in one place.
// Provides RegisterServer(), RegisterClient(), Call() — no generics at call sites.
type CustomMethod[P paramsPtr[PT], R Result, PT any] struct { ... }

func NewCustomMethod[P paramsPtr[PT], R Result, PT any](name string) *CustomMethod[P, R, PT] { ... }

// Global registry — extensions register in init(), NewServer/NewClient apply them.
type Extension struct {
    Server func(*Server) error  // optional — applied by NewServer
    Client func(*Client) error  // optional — applied by NewClient
}
func RegisterExtension(ext Extension) { ... }

package latin

import (
    "context"
    "github.com/modelcontextprotocol/go-sdk/mcp"
)

type TranslateParams struct {
    mcp.ParamsBase
    Text string `json:"text"`
}

type TranslateResult struct {
    mcp.ResultBase
    Latin string `json:"latin"`
}

// One declaration — name + types captured once
var Method = mcp.NewCustomMethod[*TranslateParams, *TranslateResult]("latin/translate")

func init() {
    // Auto-register so consumers can just import
    mcp.RegisterExtension(mcp.Extension{
        Server: func(s *mcp.Server) error {
            return Method.RegisterServer(s, DefaultHandler)
        },
        Client: func(c *mcp.Client) error {
            return Method.RegisterClient(c)
        },
    })
}

// Domain-specific sugar — the one hand-written helper
func Translate(ctx context.Context, cs *mcp.ClientSession, text string) (*TranslateResult, error) {
    return Method.Call(ctx, cs, &TranslateParams{Text: text})
}

// Reference implementation
func DefaultHandler(ctx context.Context, ss *mcp.ServerSession, params *TranslateParams) (*TranslateResult, error) {
    return &TranslateResult{Latin: translate(params.Text)}, nil
}

import "github.com/acme/mcp-latin"  // init() handles all registration

// Server — extension auto-registered via init(), or override with custom handler:
server := mcp.NewServer(impl, nil)
// latin/translate already registered with DefaultHandler!
// Optional: latin.Method.RegisterServer(server, myCustomHandler) to override

// Client — nothing needed, init() handled it
client := mcp.NewClient(impl, nil)
cs, _ := client.Connect(ctx, transport, nil)

// Call — no generics, no method name strings, feels like cs.CallTool()
result, err := latin.Translate(ctx, cs, "hello")
fmt.Println(result.Latin) // "salve"